package com.example.liuhb.rxjava;

import android.app.Activity;
import android.databinding.DataBindingUtil;
import android.os.Bundle;
import android.os.Handler;
import android.os.PersistableBundle;
import android.support.annotation.Nullable;
import android.util.Log;
import android.view.View;

import com.example.liuhb.R;
import com.example.liuhb.databinding.RxjavaLayoutBinding;

import java.util.ArrayList;
import java.util.List;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Consumer;

import static android.content.ContentValues.TAG;


/**
 * Created by liu.hb on 2018/7/23.
 */

public class RxjavaDemoActivity extends Activity implements MyListView.ILoadListener {
    RxjavaLayoutBinding b;
    private List<MyData> mDatas = new ArrayList<MyData>();
    private MyAdapter mAdapter;
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        System.out.println("*************************LoginActivity.onSaveInstanceState");
    }

    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
        System.out.println("**************************LoginActivity.onRestoreInstanceState");
    }
    /**
     * 针对界面单一，静态变量数量不多，而且不是被很多类所引用，并且这些类引用静态变量的次数不是很频繁，只有手动触发
     * 保存静态变量
     * @param outState
     * @param outPersistentState
     */
    @Override
    public void onSaveInstanceState(Bundle outState, PersistableBundle outPersistentState) {
        super.onSaveInstanceState(outState, outPersistentState);
    }

    /**
     * 恢复我们的静态变量到内存
     * @param savedInstanceState
     * @param persistentState
     */
    @Override
    public void onRestoreInstanceState(Bundle savedInstanceState, PersistableBundle persistentState) {
        super.onRestoreInstanceState(savedInstanceState, persistentState);
    }

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        b = DataBindingUtil.setContentView(this, R.layout.rxjava_layout);
        initData();//该方法初始化数据
        b.listView.setOnILoadListener(this);
        mAdapter = new MyAdapter(this, mDatas);
        b.listView.setAdapter(mAdapter);
    }

    private void initData() {
        for(int i = 0;i<3;i++){
            MyData md = new MyData("你好，我是提前设定的");
            mDatas.add(md);
        }
    }
    /**
     * 该方法提供模拟的加载数据
     */
    private void getLoadData() {
        for(int i = 0;i<3;i++){
            MyData md = new MyData("你好，我是加载进来的"+i);
            mDatas.add(md);
        }

    }



    //重写回调方法
    public void loadData() {

        //注意之所以使用Handlder，主要是想让下面的
        //操作延迟5秒钟，以体现效果。实际开发中不需要
        Handler mHandler = new Handler();
        mHandler.postDelayed(new Runnable(){


            public void run() {

                //获得加载数据
                getLoadData();
                //然后通知MyListView刷新界面
                mAdapter.notifyDataSetChanged();

                //然后通知加载数据已经完成了

                b.listView.loadFinish();
            }

        }, 5000);


    }
    public void btnRxjava(View view) {
        /**
         * 创建一个上游Observable(被观察者)：
         * @prams Emitter是发射器的意思，这个就是用来发出事件。
         * 最为关键的是onComplete和onError必须唯一并且互斥, 即不能发多个onComplete,
         * 也不能发多个onError, 也不能先发一个onComplete, 然后再发一个onError, 反之亦然。
         * 上游可以发送无限个onNext, 下游也可以接收无限个onNext。
        当上游发送了一个onComplete后, 上游onComplete之后的事件将会继续发送,
        而下游收到onComplete事件之后将不再继续接收事件。
        当上游发送了一个onError后, 上游onError之后的事件将继续发送, 而下游收到onError事件之后将不再继续接收事件。
        上游可以不发送onComplete或onError。
         */
        Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "emit 1");
                emitter.onNext(1);
                Log.d(TAG, "emit 2");
                emitter.onNext(2);
                Log.d(TAG, "emit 3");
                emitter.onNext(3);
                Log.d(TAG, "emit complete");
                emitter.onComplete();
                Log.d(TAG, "emit 4");
                emitter.onNext(4);
            }
        });
        //创建一个下游 Observer(观察者)
        Observer<Integer> observer = new Observer<Integer>() {
            private Disposable mDisposable;
            private int i;

            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "subscribe");
                mDisposable = d;
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "" + value);
                i++;
                if (i == 2) {
                    Log.d(TAG, "dispose");
                    mDisposable.dispose();
                    Log.d(TAG, "isDisposed : " + mDisposable.isDisposed());
                }
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "error");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "complete");
            }
        };
        //建立连接
        observable.subscribe(observer);

    }

    /**
     * 带有一个Consumer参数的方法表示下游只关心onNext事件, 其他的事件我假装没看见
     * @param view
     */
    public void btnRxjava1(View view) {
        Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "emit 1");
                emitter.onNext(1);
                Log.d(TAG, "emit 2");
                emitter.onNext(2);
                Log.d(TAG, "emit 3");
                emitter.onNext(3);
                Log.d(TAG, "emit complete");
                emitter.onComplete();
                Log.d(TAG, "emit 4");
                emitter.onNext(4);

            }
        });
        Consumer<Integer> observer=new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "onNext: " + integer);
            }
        };
        observable.subscribe(observer);
    }
}
